﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using Pharmacy.Entities;
using Pharmacy.Data;
using Pharmacy.Data.Bases;

#endregion

namespace Pharmacy.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
		private static volatile Configuration _config = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <see cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("Pharmacy.Data") as NetTiersServiceSection;
				}

				#region Design-Time Support

				if ( _section == null )
				{
					// lastly, try to find the specific NetTiersServiceSection for this assembly
					foreach ( ConfigurationSection temp in Configuration.Sections )
					{
						if ( temp is NetTiersServiceSection )
						{
							_section = temp as NetTiersServiceSection;
							break;
						}
					}
				}

				#endregion Design-Time Support
				
				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#region Design-Time Support

		/// <summary>
		/// Gets a reference to the application configuration object.
		/// </summary>
		public static Configuration Configuration
		{
			get
			{
				if ( _config == null )
				{
					// load specific config file
					if ( HttpContext.Current != null )
					{
						_config = WebConfigurationManager.OpenWebConfiguration("~");
					}
					else
					{
						String configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile.Replace(".config", "").Replace(".temp", "");

						// check for design mode
						if ( configFile.ToLower().Contains("devenv.exe") )
						{
							_config = GetDesignTimeConfig();
						}
						else
						{
							_config = ConfigurationManager.OpenExeConfiguration(configFile);
						}
					}
				}

				return _config;
			}
		}

		private static Configuration GetDesignTimeConfig()
		{
			ExeConfigurationFileMap configMap = null;
			Configuration config = null;
			String path = null;

			// Get an instance of the currently running Visual Studio IDE.
			EnvDTE80.DTE2 dte = (EnvDTE80.DTE2) System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.9.0");
			
			if ( dte != null )
			{
				dte.SuppressUI = true;

				EnvDTE.ProjectItem item = dte.Solution.FindProjectItem("web.config");
				if ( item != null )
				{
					if (!item.ContainingProject.FullName.ToLower().StartsWith("http:"))
               {
                  System.IO.FileInfo info = new System.IO.FileInfo(item.ContainingProject.FullName);
                  path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = path;
               }
               else
               {
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = item.get_FileNames(0);
               }}

				/*
				Array projects = (Array) dte2.ActiveSolutionProjects;
				EnvDTE.Project project = (EnvDTE.Project) projects.GetValue(0);
				System.IO.FileInfo info;

				foreach ( EnvDTE.ProjectItem item in project.ProjectItems )
				{
					if ( String.Compare(item.Name, "web.config", true) == 0 )
					{
						info = new System.IO.FileInfo(project.FullName);
						path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
						configMap = new ExeConfigurationFileMap();
						configMap.ExeConfigFilename = path;
						break;
					}
				}
				*/
			}

			config = ConfigurationManager.OpenMappedExeConfiguration(configMap, ConfigurationUserLevel.None);
			return config;
		}

		#endregion Design-Time Support

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
					// use default ConnectionStrings if _section has already been discovered
					if ( _config == null && _section != null )
					{
						return WebConfigurationManager.ConnectionStrings;
					}
					
					return Configuration.ConnectionStrings.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name, conn.ConnectionString));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;


			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region GroupProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Group"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GroupProviderBase GroupProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GroupProvider;
			}
		}
		
		#endregion
		
		#region ShelfProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Shelf"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ShelfProviderBase ShelfProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ShelfProvider;
			}
		}
		
		#endregion
		
		#region MarkUpTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MarkUpType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MarkUpTypeProviderBase MarkUpTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MarkUpTypeProvider;
			}
		}
		
		#endregion
		
		#region WebUserProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="WebUser"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static WebUserProviderBase WebUserProvider
		{
			get 
			{
				LoadProviders();
				return _provider.WebUserProvider;
			}
		}
		
		#endregion
		
		#region StockProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Stock"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockProviderBase StockProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockProvider;
			}
		}
		
		#endregion
		
		#region SupplierProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Supplier"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SupplierProviderBase SupplierProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SupplierProvider;
			}
		}
		
		#endregion
		
		#region UnitTableProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UnitTable"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UnitTableProviderBase UnitTableProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UnitTableProvider;
			}
		}
		
		#endregion
		
		#region ClassificationProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Classification"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClassificationProviderBase ClassificationProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClassificationProvider;
			}
		}
		
		#endregion
		
		#region PoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Po"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PoProviderBase PoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PoProvider;
			}
		}
		
		#endregion
		
		#region AdjustmentProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Adjustment"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdjustmentProviderBase AdjustmentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdjustmentProvider;
			}
		}
		
		#endregion
		
		#region DrugDispoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DrugDispo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DrugDispoProviderBase DrugDispoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DrugDispoProvider;
			}
		}
		
		#endregion
		
		#region StockOutProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockOut"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockOutProviderBase StockOutProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockOutProvider;
			}
		}
		
		#endregion
		
		#region RequiredAdjustmentProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="RequiredAdjustment"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RequiredAdjustmentProviderBase RequiredAdjustmentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RequiredAdjustmentProvider;
			}
		}
		
		#endregion
		
		#region StockOutDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockOutDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockOutDetailsProviderBase StockOutDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockOutDetailsProvider;
			}
		}
		
		#endregion
		
		#region PrescriptionVoidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PrescriptionVoid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PrescriptionVoidProviderBase PrescriptionVoidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PrescriptionVoidProvider;
			}
		}
		
		#endregion
		
		#region GrnProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Grn"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GrnProviderBase GrnProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GrnProvider;
			}
		}
		
		#endregion
		
		#region PrescriptionDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PrescriptionDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PrescriptionDetailProviderBase PrescriptionDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PrescriptionDetailProvider;
			}
		}
		
		#endregion
		
		#region GrnDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GrnDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GrnDetailsProviderBase GrnDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GrnDetailsProvider;
			}
		}
		
		#endregion
		
		#region DrugDiscountProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DrugDiscount"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DrugDiscountProviderBase DrugDiscountProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DrugDiscountProvider;
			}
		}
		
		#endregion
		
		#region PrescriptionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Prescription"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PrescriptionProviderBase PrescriptionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PrescriptionProvider;
			}
		}
		
		#endregion
		
		#region GrnVoidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GrnVoid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GrnVoidProviderBase GrnVoidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GrnVoidProvider;
			}
		}
		
		#endregion
		
		#region AdjustmentDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AdjustmentDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdjustmentDetailsProviderBase AdjustmentDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdjustmentDetailsProvider;
			}
		}
		
		#endregion
		
		#region PoDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PoDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PoDetailsProviderBase PoDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PoDetailsProvider;
			}
		}
		
		#endregion
		
		
		#region CmsPatientProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CmsPatient"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CmsPatientProviderBase CmsPatientProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CmsPatientProvider;
			}
		}
		
		#endregion
		
		#region DeliveryNoteDetailsProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DeliveryNoteDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DeliveryNoteDetailsProviderBase DeliveryNoteDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DeliveryNoteDetailsProvider;
			}
		}
		
		#endregion
		
		#region DeliveryNoteHistoryProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DeliveryNoteHistory"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DeliveryNoteHistoryProviderBase DeliveryNoteHistoryProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DeliveryNoteHistoryProvider;
			}
		}
		
		#endregion
		
		#region GdProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Gd"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GdProviderBase GdProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GdProvider;
			}
		}
		
		#endregion
		
		#region ImportPoDetailsProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ImportPoDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ImportPoDetailsProviderBase ImportPoDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ImportPoDetailsProvider;
			}
		}
		
		#endregion
		
		#region PdProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Pd"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PdProviderBase PdProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PdProvider;
			}
		}
		
		#endregion
		
		#region StockWarningProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockWarning"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockWarningProviderBase StockWarningProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockWarningProvider;
			}
		}
		
		#endregion
		
		#region ViewRequiredAdjustmentProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ViewRequiredAdjustment"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ViewRequiredAdjustmentProviderBase ViewRequiredAdjustmentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ViewRequiredAdjustmentProvider;
			}
		}
		
		#endregion
		
		#endregion
	}
	
	#region Query/Filters
		
	#region GroupFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Group"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupFilters : GroupFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupFilters class.
		/// </summary>
		public GroupFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupFilters
	
	#region GroupQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GroupParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Group"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupQuery : GroupParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupQuery class.
		/// </summary>
		public GroupQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupQuery
		
	#region ShelfFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Shelf"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ShelfFilters : ShelfFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ShelfFilters class.
		/// </summary>
		public ShelfFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ShelfFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ShelfFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ShelfFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ShelfFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ShelfFilters
	
	#region ShelfQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ShelfParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Shelf"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ShelfQuery : ShelfParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ShelfQuery class.
		/// </summary>
		public ShelfQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ShelfQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ShelfQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ShelfQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ShelfQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ShelfQuery
		
	#region MarkUpTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MarkUpType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MarkUpTypeFilters : MarkUpTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MarkUpTypeFilters class.
		/// </summary>
		public MarkUpTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MarkUpTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MarkUpTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MarkUpTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MarkUpTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MarkUpTypeFilters
	
	#region MarkUpTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MarkUpTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MarkUpType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MarkUpTypeQuery : MarkUpTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MarkUpTypeQuery class.
		/// </summary>
		public MarkUpTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MarkUpTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MarkUpTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MarkUpTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MarkUpTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MarkUpTypeQuery
		
	#region WebUserFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="WebUser"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WebUserFilters : WebUserFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WebUserFilters class.
		/// </summary>
		public WebUserFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the WebUserFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WebUserFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WebUserFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WebUserFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WebUserFilters
	
	#region WebUserQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="WebUserParameterBuilder"/> class
	/// that is used exclusively with a <see cref="WebUser"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WebUserQuery : WebUserParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WebUserQuery class.
		/// </summary>
		public WebUserQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the WebUserQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WebUserQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WebUserQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WebUserQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WebUserQuery
		
	#region StockFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Stock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilters : StockFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilters class.
		/// </summary>
		public StockFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilters
	
	#region StockQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Stock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockQuery : StockParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockQuery class.
		/// </summary>
		public StockQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockQuery
		
	#region SupplierFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Supplier"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SupplierFilters : SupplierFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SupplierFilters class.
		/// </summary>
		public SupplierFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SupplierFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SupplierFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SupplierFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SupplierFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SupplierFilters
	
	#region SupplierQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SupplierParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Supplier"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SupplierQuery : SupplierParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SupplierQuery class.
		/// </summary>
		public SupplierQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SupplierQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SupplierQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SupplierQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SupplierQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SupplierQuery
		
	#region UnitTableFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UnitTable"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UnitTableFilters : UnitTableFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UnitTableFilters class.
		/// </summary>
		public UnitTableFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UnitTableFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UnitTableFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UnitTableFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UnitTableFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UnitTableFilters
	
	#region UnitTableQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UnitTableParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UnitTable"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UnitTableQuery : UnitTableParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UnitTableQuery class.
		/// </summary>
		public UnitTableQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UnitTableQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UnitTableQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UnitTableQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UnitTableQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UnitTableQuery
		
	#region ClassificationFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Classification"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClassificationFilters : ClassificationFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClassificationFilters class.
		/// </summary>
		public ClassificationFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClassificationFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClassificationFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClassificationFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClassificationFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClassificationFilters
	
	#region ClassificationQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClassificationParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Classification"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClassificationQuery : ClassificationParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClassificationQuery class.
		/// </summary>
		public ClassificationQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClassificationQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClassificationQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClassificationQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClassificationQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClassificationQuery
		
	#region PoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Po"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PoFilters : PoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PoFilters class.
		/// </summary>
		public PoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PoFilters
	
	#region PoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Po"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PoQuery : PoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PoQuery class.
		/// </summary>
		public PoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PoQuery
		
	#region AdjustmentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Adjustment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdjustmentFilters : AdjustmentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdjustmentFilters class.
		/// </summary>
		public AdjustmentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdjustmentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdjustmentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdjustmentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdjustmentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdjustmentFilters
	
	#region AdjustmentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdjustmentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Adjustment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdjustmentQuery : AdjustmentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdjustmentQuery class.
		/// </summary>
		public AdjustmentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdjustmentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdjustmentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdjustmentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdjustmentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdjustmentQuery
		
	#region DrugDispoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DrugDispo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DrugDispoFilters : DrugDispoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DrugDispoFilters class.
		/// </summary>
		public DrugDispoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DrugDispoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DrugDispoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DrugDispoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DrugDispoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DrugDispoFilters
	
	#region DrugDispoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DrugDispoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DrugDispo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DrugDispoQuery : DrugDispoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DrugDispoQuery class.
		/// </summary>
		public DrugDispoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DrugDispoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DrugDispoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DrugDispoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DrugDispoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DrugDispoQuery
		
	#region StockOutFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockOut"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockOutFilters : StockOutFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockOutFilters class.
		/// </summary>
		public StockOutFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockOutFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockOutFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockOutFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockOutFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockOutFilters
	
	#region StockOutQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockOutParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockOut"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockOutQuery : StockOutParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockOutQuery class.
		/// </summary>
		public StockOutQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockOutQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockOutQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockOutQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockOutQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockOutQuery
		
	#region RequiredAdjustmentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="RequiredAdjustment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RequiredAdjustmentFilters : RequiredAdjustmentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RequiredAdjustmentFilters class.
		/// </summary>
		public RequiredAdjustmentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RequiredAdjustmentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RequiredAdjustmentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RequiredAdjustmentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RequiredAdjustmentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RequiredAdjustmentFilters
	
	#region RequiredAdjustmentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RequiredAdjustmentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="RequiredAdjustment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RequiredAdjustmentQuery : RequiredAdjustmentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RequiredAdjustmentQuery class.
		/// </summary>
		public RequiredAdjustmentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RequiredAdjustmentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RequiredAdjustmentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RequiredAdjustmentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RequiredAdjustmentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RequiredAdjustmentQuery
		
	#region StockOutDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockOutDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockOutDetailsFilters : StockOutDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockOutDetailsFilters class.
		/// </summary>
		public StockOutDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockOutDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockOutDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockOutDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockOutDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockOutDetailsFilters
	
	#region StockOutDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockOutDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockOutDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockOutDetailsQuery : StockOutDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockOutDetailsQuery class.
		/// </summary>
		public StockOutDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockOutDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockOutDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockOutDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockOutDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockOutDetailsQuery
		
	#region PrescriptionVoidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PrescriptionVoid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrescriptionVoidFilters : PrescriptionVoidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrescriptionVoidFilters class.
		/// </summary>
		public PrescriptionVoidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionVoidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrescriptionVoidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionVoidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrescriptionVoidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrescriptionVoidFilters
	
	#region PrescriptionVoidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PrescriptionVoidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PrescriptionVoid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrescriptionVoidQuery : PrescriptionVoidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrescriptionVoidQuery class.
		/// </summary>
		public PrescriptionVoidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionVoidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrescriptionVoidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionVoidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrescriptionVoidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrescriptionVoidQuery
		
	#region GrnFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Grn"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrnFilters : GrnFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrnFilters class.
		/// </summary>
		public GrnFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrnFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrnFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrnFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrnFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrnFilters
	
	#region GrnQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GrnParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Grn"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrnQuery : GrnParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrnQuery class.
		/// </summary>
		public GrnQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrnQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrnQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrnQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrnQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrnQuery
		
	#region PrescriptionDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PrescriptionDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrescriptionDetailFilters : PrescriptionDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrescriptionDetailFilters class.
		/// </summary>
		public PrescriptionDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrescriptionDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrescriptionDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrescriptionDetailFilters
	
	#region PrescriptionDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PrescriptionDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PrescriptionDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrescriptionDetailQuery : PrescriptionDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrescriptionDetailQuery class.
		/// </summary>
		public PrescriptionDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrescriptionDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrescriptionDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrescriptionDetailQuery
		
	#region GrnDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GrnDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrnDetailsFilters : GrnDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrnDetailsFilters class.
		/// </summary>
		public GrnDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrnDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrnDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrnDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrnDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrnDetailsFilters
	
	#region GrnDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GrnDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GrnDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrnDetailsQuery : GrnDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrnDetailsQuery class.
		/// </summary>
		public GrnDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrnDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrnDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrnDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrnDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrnDetailsQuery
		
	#region DrugDiscountFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DrugDiscount"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DrugDiscountFilters : DrugDiscountFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DrugDiscountFilters class.
		/// </summary>
		public DrugDiscountFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DrugDiscountFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DrugDiscountFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DrugDiscountFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DrugDiscountFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DrugDiscountFilters
	
	#region DrugDiscountQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DrugDiscountParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DrugDiscount"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DrugDiscountQuery : DrugDiscountParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DrugDiscountQuery class.
		/// </summary>
		public DrugDiscountQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DrugDiscountQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DrugDiscountQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DrugDiscountQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DrugDiscountQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DrugDiscountQuery
		
	#region PrescriptionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Prescription"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrescriptionFilters : PrescriptionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrescriptionFilters class.
		/// </summary>
		public PrescriptionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrescriptionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrescriptionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrescriptionFilters
	
	#region PrescriptionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PrescriptionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Prescription"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PrescriptionQuery : PrescriptionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PrescriptionQuery class.
		/// </summary>
		public PrescriptionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PrescriptionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PrescriptionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PrescriptionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PrescriptionQuery
		
	#region GrnVoidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GrnVoid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrnVoidFilters : GrnVoidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrnVoidFilters class.
		/// </summary>
		public GrnVoidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrnVoidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrnVoidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrnVoidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrnVoidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrnVoidFilters
	
	#region GrnVoidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GrnVoidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GrnVoid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrnVoidQuery : GrnVoidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrnVoidQuery class.
		/// </summary>
		public GrnVoidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrnVoidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrnVoidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrnVoidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrnVoidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrnVoidQuery
		
	#region AdjustmentDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AdjustmentDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdjustmentDetailsFilters : AdjustmentDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdjustmentDetailsFilters class.
		/// </summary>
		public AdjustmentDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdjustmentDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdjustmentDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdjustmentDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdjustmentDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdjustmentDetailsFilters
	
	#region AdjustmentDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdjustmentDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AdjustmentDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdjustmentDetailsQuery : AdjustmentDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdjustmentDetailsQuery class.
		/// </summary>
		public AdjustmentDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdjustmentDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdjustmentDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdjustmentDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdjustmentDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdjustmentDetailsQuery
		
	#region PoDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PoDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PoDetailsFilters : PoDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PoDetailsFilters class.
		/// </summary>
		public PoDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PoDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PoDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PoDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PoDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PoDetailsFilters
	
	#region PoDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PoDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PoDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PoDetailsQuery : PoDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PoDetailsQuery class.
		/// </summary>
		public PoDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PoDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PoDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PoDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PoDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PoDetailsQuery
		
	#region CmsPatientFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CmsPatient"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CmsPatientFilters : CmsPatientFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CmsPatientFilters class.
		/// </summary>
		public CmsPatientFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CmsPatientFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CmsPatientFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CmsPatientFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CmsPatientFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CmsPatientFilters
	
	#region CmsPatientQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CmsPatientParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CmsPatient"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CmsPatientQuery : CmsPatientParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CmsPatientQuery class.
		/// </summary>
		public CmsPatientQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CmsPatientQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CmsPatientQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CmsPatientQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CmsPatientQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CmsPatientQuery
		
	#region DeliveryNoteDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DeliveryNoteDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DeliveryNoteDetailsFilters : DeliveryNoteDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteDetailsFilters class.
		/// </summary>
		public DeliveryNoteDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DeliveryNoteDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DeliveryNoteDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DeliveryNoteDetailsFilters
	
	#region DeliveryNoteDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DeliveryNoteDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DeliveryNoteDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DeliveryNoteDetailsQuery : DeliveryNoteDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteDetailsQuery class.
		/// </summary>
		public DeliveryNoteDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DeliveryNoteDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DeliveryNoteDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DeliveryNoteDetailsQuery
		
	#region DeliveryNoteHistoryFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DeliveryNoteHistory"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DeliveryNoteHistoryFilters : DeliveryNoteHistoryFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteHistoryFilters class.
		/// </summary>
		public DeliveryNoteHistoryFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteHistoryFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DeliveryNoteHistoryFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteHistoryFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DeliveryNoteHistoryFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DeliveryNoteHistoryFilters
	
	#region DeliveryNoteHistoryQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DeliveryNoteHistoryParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DeliveryNoteHistory"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DeliveryNoteHistoryQuery : DeliveryNoteHistoryParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteHistoryQuery class.
		/// </summary>
		public DeliveryNoteHistoryQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteHistoryQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DeliveryNoteHistoryQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DeliveryNoteHistoryQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DeliveryNoteHistoryQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DeliveryNoteHistoryQuery
		
	#region GdFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Gd"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GdFilters : GdFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GdFilters class.
		/// </summary>
		public GdFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GdFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GdFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GdFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GdFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GdFilters
	
	#region GdQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GdParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Gd"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GdQuery : GdParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GdQuery class.
		/// </summary>
		public GdQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GdQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GdQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GdQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GdQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GdQuery
		
	#region ImportPoDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ImportPoDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImportPoDetailsFilters : ImportPoDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImportPoDetailsFilters class.
		/// </summary>
		public ImportPoDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImportPoDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImportPoDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImportPoDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImportPoDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImportPoDetailsFilters
	
	#region ImportPoDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ImportPoDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ImportPoDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImportPoDetailsQuery : ImportPoDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImportPoDetailsQuery class.
		/// </summary>
		public ImportPoDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImportPoDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImportPoDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImportPoDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImportPoDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImportPoDetailsQuery
		
	#region PdFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Pd"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PdFilters : PdFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PdFilters class.
		/// </summary>
		public PdFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PdFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PdFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PdFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PdFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PdFilters
	
	#region PdQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PdParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Pd"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PdQuery : PdParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PdQuery class.
		/// </summary>
		public PdQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PdQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PdQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PdQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PdQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PdQuery
		
	#region StockWarningFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockWarning"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockWarningFilters : StockWarningFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockWarningFilters class.
		/// </summary>
		public StockWarningFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockWarningFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockWarningFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockWarningFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockWarningFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockWarningFilters
	
	#region StockWarningQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockWarningParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockWarning"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockWarningQuery : StockWarningParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockWarningQuery class.
		/// </summary>
		public StockWarningQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockWarningQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockWarningQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockWarningQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockWarningQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockWarningQuery
		
	#region ViewRequiredAdjustmentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ViewRequiredAdjustment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ViewRequiredAdjustmentFilters : ViewRequiredAdjustmentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ViewRequiredAdjustmentFilters class.
		/// </summary>
		public ViewRequiredAdjustmentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ViewRequiredAdjustmentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ViewRequiredAdjustmentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ViewRequiredAdjustmentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ViewRequiredAdjustmentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ViewRequiredAdjustmentFilters
	
	#region ViewRequiredAdjustmentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ViewRequiredAdjustmentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ViewRequiredAdjustment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ViewRequiredAdjustmentQuery : ViewRequiredAdjustmentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ViewRequiredAdjustmentQuery class.
		/// </summary>
		public ViewRequiredAdjustmentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ViewRequiredAdjustmentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ViewRequiredAdjustmentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ViewRequiredAdjustmentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ViewRequiredAdjustmentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ViewRequiredAdjustmentQuery
	#endregion

	
}
